home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / include / openssl / asn1t.h < prev    next >
C/C++ Source or Header  |  2006-04-25  |  27KB  |  847 lines
  1. /* asn1t.h */
  2. /* Written by Dr Stephen N Henson (shenson@bigfoot.com) for the OpenSSL
  3.  * project 2000.
  4.  */
  5. /* ====================================================================
  6.  * Copyright (c) 2000 The OpenSSL Project.  All rights reserved.
  7.  *
  8.  * Redistribution and use in source and binary forms, with or without
  9.  * modification, are permitted provided that the following conditions
  10.  * are met:
  11.  *
  12.  * 1. Redistributions of source code must retain the above copyright
  13.  *    notice, this list of conditions and the following disclaimer. 
  14.  *
  15.  * 2. Redistributions in binary form must reproduce the above copyright
  16.  *    notice, this list of conditions and the following disclaimer in
  17.  *    the documentation and/or other materials provided with the
  18.  *    distribution.
  19.  *
  20.  * 3. All advertising materials mentioning features or use of this
  21.  *    software must display the following acknowledgment:
  22.  *    "This product includes software developed by the OpenSSL Project
  23.  *    for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
  24.  *
  25.  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
  26.  *    endorse or promote products derived from this software without
  27.  *    prior written permission. For written permission, please contact
  28.  *    licensing@OpenSSL.org.
  29.  *
  30.  * 5. Products derived from this software may not be called "OpenSSL"
  31.  *    nor may "OpenSSL" appear in their names without prior written
  32.  *    permission of the OpenSSL Project.
  33.  *
  34.  * 6. Redistributions of any form whatsoever must retain the following
  35.  *    acknowledgment:
  36.  *    "This product includes software developed by the OpenSSL Project
  37.  *    for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
  38.  *
  39.  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
  40.  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  41.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  42.  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
  43.  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  44.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  45.  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  46.  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  47.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  48.  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  49.  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  50.  * OF THE POSSIBILITY OF SUCH DAMAGE.
  51.  * ====================================================================
  52.  *
  53.  * This product includes cryptographic software written by Eric Young
  54.  * (eay@cryptsoft.com).  This product includes software written by Tim
  55.  * Hudson (tjh@cryptsoft.com).
  56.  *
  57.  */
  58. #ifndef HEADER_ASN1T_H
  59. #define HEADER_ASN1T_H
  60.  
  61. #include <stddef.h>
  62. #include <openssl/e_os2.h>
  63. #include <openssl/asn1.h>
  64.  
  65. #ifdef OPENSSL_BUILD_SHLIBCRYPTO
  66. # undef OPENSSL_EXTERN
  67. # define OPENSSL_EXTERN OPENSSL_EXPORT
  68. #endif
  69.  
  70. /* ASN1 template defines, structures and functions */
  71.  
  72. #ifdef  __cplusplus
  73. extern "C" {
  74. #endif
  75.  
  76.  
  77. #ifndef OPENSSL_EXPORT_VAR_AS_FUNCTION
  78.  
  79. /* Macro to obtain ASN1_ADB pointer from a type (only used internally) */
  80. #define ASN1_ADB_ptr(iptr) ((const ASN1_ADB *)(iptr))
  81.  
  82.  
  83. /* Macros for start and end of ASN1_ITEM definition */
  84.  
  85. #define ASN1_ITEM_start(itname) \
  86.     OPENSSL_GLOBAL const ASN1_ITEM itname##_it = {
  87.  
  88. #define ASN1_ITEM_end(itname) \
  89.         };
  90.  
  91. #else
  92.  
  93. /* Macro to obtain ASN1_ADB pointer from a type (only used internally) */
  94. #define ASN1_ADB_ptr(iptr) ((const ASN1_ADB *)(iptr()))
  95.  
  96.  
  97. /* Macros for start and end of ASN1_ITEM definition */
  98.  
  99. #define ASN1_ITEM_start(itname) \
  100.     const ASN1_ITEM * itname##_it(void) \
  101.     { \
  102.         static const ASN1_ITEM local_it = { \
  103.  
  104. #define ASN1_ITEM_end(itname) \
  105.         }; \
  106.     return &local_it; \
  107.     }
  108.  
  109. #endif
  110.  
  111.  
  112. /* Macros to aid ASN1 template writing */
  113.  
  114. #define ASN1_ITEM_TEMPLATE(tname) \
  115.     const static ASN1_TEMPLATE tname##_item_tt 
  116.  
  117. #define ASN1_ITEM_TEMPLATE_END(tname) \
  118.     ;\
  119.     ASN1_ITEM_start(tname) \
  120.         ASN1_ITYPE_PRIMITIVE,\
  121.         -1,\
  122.         &tname##_item_tt,\
  123.         0,\
  124.         NULL,\
  125.         0,\
  126.         #tname \
  127.     ASN1_ITEM_end(tname)
  128.  
  129.  
  130. /* This is a ASN1 type which just embeds a template */
  131.  
  132. /* This pair helps declare a SEQUENCE. We can do:
  133.  *
  134.  *     ASN1_SEQUENCE(stname) = {
  135.  *         ... SEQUENCE components ...
  136.  *     } ASN1_SEQUENCE_END(stname)
  137.  *
  138.  *     This will produce an ASN1_ITEM called stname_it
  139.  *    for a structure called stname.
  140.  *
  141.  *     If you want the same structure but a different
  142.  *    name then use:
  143.  *
  144.  *     ASN1_SEQUENCE(itname) = {
  145.  *         ... SEQUENCE components ...
  146.  *     } ASN1_SEQUENCE_END_name(stname, itname)
  147.  *
  148.  *    This will create an item called itname_it using
  149.  *    a structure called stname.
  150.  */
  151.  
  152. #define ASN1_SEQUENCE(tname) \
  153.     const static ASN1_TEMPLATE tname##_seq_tt[] 
  154.  
  155. #define ASN1_SEQUENCE_END(stname) ASN1_SEQUENCE_END_name(stname, stname)
  156.  
  157. #define ASN1_SEQUENCE_END_name(stname, tname) \
  158.     ;\
  159.     ASN1_ITEM_start(tname) \
  160.         ASN1_ITYPE_SEQUENCE,\
  161.         V_ASN1_SEQUENCE,\
  162.         tname##_seq_tt,\
  163.         sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE),\
  164.         NULL,\
  165.         sizeof(stname),\
  166.         #stname \
  167.     ASN1_ITEM_end(tname)
  168.  
  169. #define ASN1_SEQUENCE_cb(tname, cb) \
  170.     const static ASN1_AUX tname##_aux = {NULL, 0, 0, 0, cb, 0}; \
  171.     ASN1_SEQUENCE(tname)
  172.  
  173. #define ASN1_BROKEN_SEQUENCE(tname) \
  174.     const static ASN1_AUX tname##_aux = {NULL, ASN1_AFLG_BROKEN, 0, 0, 0, 0}; \
  175.     ASN1_SEQUENCE(tname)
  176.  
  177. #define ASN1_SEQUENCE_ref(tname, cb, lck) \
  178.     const static ASN1_AUX tname##_aux = {NULL, ASN1_AFLG_REFCOUNT, offsetof(tname, references), lck, cb, 0}; \
  179.     ASN1_SEQUENCE(tname)
  180.  
  181. #define ASN1_SEQUENCE_enc(tname, enc, cb) \
  182.     const static ASN1_AUX tname##_aux = {NULL, ASN1_AFLG_ENCODING, 0, 0, cb, offsetof(tname, enc)}; \
  183.     ASN1_SEQUENCE(tname)
  184.  
  185. #define ASN1_BROKEN_SEQUENCE_END(stname) ASN1_SEQUENCE_END_ref(stname, stname)
  186.  
  187. #define ASN1_SEQUENCE_END_enc(stname, tname) ASN1_SEQUENCE_END_ref(stname, tname)
  188.  
  189. #define ASN1_SEQUENCE_END_cb(stname, tname) ASN1_SEQUENCE_END_ref(stname, tname)
  190.  
  191. #define ASN1_SEQUENCE_END_ref(stname, tname) \
  192.     ;\
  193.     ASN1_ITEM_start(tname) \
  194.         ASN1_ITYPE_SEQUENCE,\
  195.         V_ASN1_SEQUENCE,\
  196.         tname##_seq_tt,\
  197.         sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE),\
  198.         &tname##_aux,\
  199.         sizeof(stname),\
  200.         #stname \
  201.     ASN1_ITEM_end(tname)
  202.  
  203.  
  204. /* This pair helps declare a CHOICE type. We can do:
  205.  *
  206.  *     ASN1_CHOICE(chname) = {
  207.  *         ... CHOICE options ...
  208.  *     ASN1_CHOICE_END(chname)
  209.  *
  210.  *     This will produce an ASN1_ITEM called chname_it
  211.  *    for a structure called chname. The structure
  212.  *    definition must look like this:
  213.  *    typedef struct {
  214.  *        int type;
  215.  *        union {
  216.  *            ASN1_SOMETHING *opt1;
  217.  *            ASN1_SOMEOTHER *opt2;
  218.  *        } value;
  219.  *    } chname;
  220.  *    
  221.  *    the name of the selector must be 'type'.
  222.  *     to use an alternative selector name use the
  223.  *      ASN1_CHOICE_END_selector() version.
  224.  */
  225.  
  226. #define ASN1_CHOICE(tname) \
  227.     const static ASN1_TEMPLATE tname##_ch_tt[] 
  228.  
  229. #define ASN1_CHOICE_cb(tname, cb) \
  230.     const static ASN1_AUX tname##_aux = {NULL, 0, 0, 0, cb, 0}; \
  231.     ASN1_CHOICE(tname)
  232.  
  233. #define ASN1_CHOICE_END(stname) ASN1_CHOICE_END_name(stname, stname)
  234.  
  235. #define ASN1_CHOICE_END_name(stname, tname) ASN1_CHOICE_END_selector(stname, tname, type)
  236.  
  237. #define ASN1_CHOICE_END_selector(stname, tname, selname) \
  238.     ;\
  239.     ASN1_ITEM_start(tname) \
  240.         ASN1_ITYPE_CHOICE,\
  241.         offsetof(stname,selname) ,\
  242.         tname##_ch_tt,\
  243.         sizeof(tname##_ch_tt) / sizeof(ASN1_TEMPLATE),\
  244.         NULL,\
  245.         sizeof(stname),\
  246.         #stname \
  247.     ASN1_ITEM_end(tname)
  248.  
  249. #define ASN1_CHOICE_END_cb(stname, tname, selname) \
  250.     ;\
  251.     ASN1_ITEM_start(tname) \
  252.         ASN1_ITYPE_CHOICE,\
  253.         offsetof(stname,selname) ,\
  254.         tname##_ch_tt,\
  255.         sizeof(tname##_ch_tt) / sizeof(ASN1_TEMPLATE),\
  256.         &tname##_aux,\
  257.         sizeof(stname),\
  258.         #stname \
  259.     ASN1_ITEM_end(tname)
  260.  
  261. /* This helps with the template wrapper form of ASN1_ITEM */
  262.  
  263. #define ASN1_EX_TEMPLATE_TYPE(flags, tag, name, type) { \
  264.     (flags), (tag), 0,\
  265.     #name, ASN1_ITEM_ref(type) }
  266.  
  267. /* These help with SEQUENCE or CHOICE components */
  268.  
  269. /* used to declare other types */
  270.  
  271. #define ASN1_EX_TYPE(flags, tag, stname, field, type) { \
  272.     (flags), (tag), offsetof(stname, field),\
  273.     #field, ASN1_ITEM_ref(type) }
  274.  
  275. /* used when the structure is combined with the parent */
  276.  
  277. #define ASN1_EX_COMBINE(flags, tag, type) { \
  278.     (flags)|ASN1_TFLG_COMBINE, (tag), 0, NULL, ASN1_ITEM_ref(type) }
  279.  
  280. /* implicit and explicit helper macros */
  281.  
  282. #define ASN1_IMP_EX(stname, field, type, tag, ex) \
  283.         ASN1_EX_TYPE(ASN1_TFLG_IMPLICIT | ex, tag, stname, field, type)
  284.  
  285. #define ASN1_EXP_EX(stname, field, type, tag, ex) \
  286.         ASN1_EX_TYPE(ASN1_TFLG_EXPLICIT | ex, tag, stname, field, type)
  287.  
  288. /* Any defined by macros: the field used is in the table itself */
  289.  
  290. #ifndef OPENSSL_EXPORT_VAR_AS_FUNCTION
  291. #define ASN1_ADB_OBJECT(tblname) { ASN1_TFLG_ADB_OID, -1, 0, #tblname, (const ASN1_ITEM *)&(tblname##_adb) }
  292. #define ASN1_ADB_INTEGER(tblname) { ASN1_TFLG_ADB_INT, -1, 0, #tblname, (const ASN1_ITEM *)&(tblname##_adb) }
  293. #else
  294. #define ASN1_ADB_OBJECT(tblname) { ASN1_TFLG_ADB_OID, -1, 0, #tblname, tblname##_adb }
  295. #define ASN1_ADB_INTEGER(tblname) { ASN1_TFLG_ADB_INT, -1, 0, #tblname, tblname##_adb }
  296. #endif
  297. /* Plain simple type */
  298. #define ASN1_SIMPLE(stname, field, type) ASN1_EX_TYPE(0,0, stname, field, type)
  299.  
  300. /* OPTIONAL simple type */
  301. #define ASN1_OPT(stname, field, type) ASN1_EX_TYPE(ASN1_TFLG_OPTIONAL, 0, stname, field, type)
  302.  
  303. /* IMPLICIT tagged simple type */
  304. #define ASN1_IMP(stname, field, type, tag) ASN1_IMP_EX(stname, field, type, tag, 0)
  305.  
  306. /* IMPLICIT tagged OPTIONAL simple type */
  307. #define ASN1_IMP_OPT(stname, field, type, tag) ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_OPTIONAL)
  308.  
  309. /* Same as above but EXPLICIT */
  310.  
  311. #define ASN1_EXP(stname, field, type, tag) ASN1_EXP_EX(stname, field, type, tag, 0)
  312. #define ASN1_EXP_OPT(stname, field, type, tag) ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_OPTIONAL)
  313.  
  314. /* SEQUENCE OF type */
  315. #define ASN1_SEQUENCE_OF(stname, field, type) \
  316.         ASN1_EX_TYPE(ASN1_TFLG_SEQUENCE_OF, 0, stname, field, type)
  317.  
  318. /* OPTIONAL SEQUENCE OF */
  319. #define ASN1_SEQUENCE_OF_OPT(stname, field, type) \
  320.         ASN1_EX_TYPE(ASN1_TFLG_SEQUENCE_OF|ASN1_TFLG_OPTIONAL, 0, stname, field, type)
  321.  
  322. /* Same as above but for SET OF */
  323.  
  324. #define ASN1_SET_OF(stname, field, type) \
  325.         ASN1_EX_TYPE(ASN1_TFLG_SET_OF, 0, stname, field, type)
  326.  
  327. #define ASN1_SET_OF_OPT(stname, field, type) \
  328.         ASN1_EX_TYPE(ASN1_TFLG_SET_OF|ASN1_TFLG_OPTIONAL, 0, stname, field, type)
  329.  
  330. /* Finally compound types of SEQUENCE, SET, IMPLICIT, EXPLICIT and OPTIONAL */
  331.  
  332. #define ASN1_IMP_SET_OF(stname, field, type, tag) \
  333.             ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_SET_OF)
  334.  
  335. #define ASN1_EXP_SET_OF(stname, field, type, tag) \
  336.             ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_SET_OF)
  337.  
  338. #define ASN1_IMP_SET_OF_OPT(stname, field, type, tag) \
  339.             ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_SET_OF|ASN1_TFLG_OPTIONAL)
  340.  
  341. #define ASN1_EXP_SET_OF_OPT(stname, field, type, tag) \
  342.             ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_SET_OF|ASN1_TFLG_OPTIONAL)
  343.  
  344. #define ASN1_IMP_SEQUENCE_OF(stname, field, type, tag) \
  345.             ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_SEQUENCE_OF)
  346.  
  347. #define ASN1_IMP_SEQUENCE_OF_OPT(stname, field, type, tag) \
  348.             ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_SEQUENCE_OF|ASN1_TFLG_OPTIONAL)
  349.  
  350. #define ASN1_EXP_SEQUENCE_OF(stname, field, type, tag) \
  351.             ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_SEQUENCE_OF)
  352.  
  353. #define ASN1_EXP_SEQUENCE_OF_OPT(stname, field, type, tag) \
  354.             ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_SEQUENCE_OF|ASN1_TFLG_OPTIONAL)
  355.  
  356. /* Macros for the ASN1_ADB structure */
  357.  
  358. #define ASN1_ADB(name) \
  359.     const static ASN1_ADB_TABLE name##_adbtbl[] 
  360.  
  361. #ifndef OPENSSL_EXPORT_VAR_AS_FUNCTION
  362.  
  363. #define ASN1_ADB_END(name, flags, field, app_table, def, none) \
  364.     ;\
  365.     const static ASN1_ADB name##_adb = {\
  366.         flags,\
  367.         offsetof(name, field),\
  368.         app_table,\
  369.         name##_adbtbl,\
  370.         sizeof(name##_adbtbl) / sizeof(ASN1_ADB_TABLE),\
  371.         def,\
  372.         none\
  373.     }
  374.  
  375. #else
  376.  
  377. #define ASN1_ADB_END(name, flags, field, app_table, def, none) \
  378.     ;\
  379.     const static ASN1_ITEM *name##_adb(void) \
  380.     { \
  381.     const static ASN1_ADB internal_adb = \
  382.         {\
  383.         flags,\
  384.         offsetof(name, field),\
  385.         app_table,\
  386.         name##_adbtbl,\
  387.         sizeof(name##_adbtbl) / sizeof(ASN1_ADB_TABLE),\
  388.         def,\
  389.         none\
  390.         }; \
  391.         return (const ASN1_ITEM *) &internal_adb; \
  392.     } \
  393.     void dummy_function(void)
  394.  
  395. #endif
  396.  
  397. #define ADB_ENTRY(val, template) {val, template}
  398.  
  399. #define ASN1_ADB_TEMPLATE(name) \
  400.     const static ASN1_TEMPLATE name##_tt 
  401.  
  402. /* This is the ASN1 template structure that defines
  403.  * a wrapper round the actual type. It determines the
  404.  * actual position of the field in the value structure,
  405.  * various flags such as OPTIONAL and the field name.
  406.  */
  407.  
  408. struct ASN1_TEMPLATE_st {
  409. unsigned long flags;        /* Various flags */
  410. long tag;            /* tag, not used if no tagging */
  411. unsigned long offset;        /* Offset of this field in structure */
  412. #ifndef NO_ASN1_FIELD_NAMES
  413. char *field_name;        /* Field name */
  414. #endif
  415. ASN1_ITEM_EXP *item;        /* Relevant ASN1_ITEM or ASN1_ADB */
  416. };
  417.  
  418. /* Macro to extract ASN1_ITEM and ASN1_ADB pointer from ASN1_TEMPLATE */
  419.  
  420. #define ASN1_TEMPLATE_item(t) (t->item_ptr)
  421. #define ASN1_TEMPLATE_adb(t) (t->item_ptr)
  422.  
  423. typedef struct ASN1_ADB_TABLE_st ASN1_ADB_TABLE;
  424. typedef struct ASN1_ADB_st ASN1_ADB;
  425.  
  426. struct ASN1_ADB_st {
  427.     unsigned long flags;    /* Various flags */
  428.     unsigned long offset;    /* Offset of selector field */
  429.     STACK_OF(ASN1_ADB_TABLE) **app_items; /* Application defined items */
  430.     const ASN1_ADB_TABLE *tbl;    /* Table of possible types */
  431.     long tblcount;        /* Number of entries in tbl */
  432.     const ASN1_TEMPLATE *default_tt;  /* Type to use if no match */
  433.     const ASN1_TEMPLATE *null_tt;  /* Type to use if selector is NULL */
  434. };
  435.  
  436. struct ASN1_ADB_TABLE_st {
  437.     long value;        /* NID for an object or value for an int */
  438.     const ASN1_TEMPLATE tt;        /* item for this value */
  439. };
  440.  
  441. /* template flags */
  442.  
  443. /* Field is optional */
  444. #define ASN1_TFLG_OPTIONAL    (0x1)
  445.  
  446. /* Field is a SET OF */
  447. #define ASN1_TFLG_SET_OF    (0x1 << 1)
  448.  
  449. /* Field is a SEQUENCE OF */
  450. #define ASN1_TFLG_SEQUENCE_OF    (0x2 << 1)
  451.  
  452. /* Special case: this refers to a SET OF that
  453.  * will be sorted into DER order when encoded *and*
  454.  * the corresponding STACK will be modified to match
  455.  * the new order.
  456.  */
  457. #define ASN1_TFLG_SET_ORDER    (0x3 << 1)
  458.  
  459. /* Mask for SET OF or SEQUENCE OF */
  460. #define ASN1_TFLG_SK_MASK    (0x3 << 1)
  461.  
  462. /* These flags mean the tag should be taken from the
  463.  * tag field. If EXPLICIT then the underlying type
  464.  * is used for the inner tag.
  465.  */
  466.  
  467. /* IMPLICIT tagging */
  468. #define ASN1_TFLG_IMPTAG    (0x1 << 3)
  469.  
  470.  
  471. /* EXPLICIT tagging, inner tag from underlying type */
  472. #define ASN1_TFLG_EXPTAG    (0x2 << 3)
  473.  
  474. #define ASN1_TFLG_TAG_MASK    (0x3 << 3)
  475.  
  476. /* context specific IMPLICIT */
  477. #define ASN1_TFLG_IMPLICIT    ASN1_TFLG_IMPTAG|ASN1_TFLG_CONTEXT
  478.  
  479. /* context specific EXPLICIT */
  480. #define ASN1_TFLG_EXPLICIT    ASN1_TFLG_EXPTAG|ASN1_TFLG_CONTEXT
  481.  
  482. /* If tagging is in force these determine the
  483.  * type of tag to use. Otherwise the tag is
  484.  * determined by the underlying type. These 
  485.  * values reflect the actual octet format.
  486.  */
  487.  
  488. /* Universal tag */ 
  489. #define ASN1_TFLG_UNIVERSAL    (0x0<<6)
  490. /* Application tag */ 
  491. #define ASN1_TFLG_APPLICATION    (0x1<<6)
  492. /* Context specific tag */ 
  493. #define ASN1_TFLG_CONTEXT    (0x2<<6)
  494. /* Private tag */ 
  495. #define ASN1_TFLG_PRIVATE    (0x3<<6)
  496.  
  497. #define ASN1_TFLG_TAG_CLASS    (0x3<<6)
  498.  
  499. /* These are for ANY DEFINED BY type. In this case
  500.  * the 'item' field points to an ASN1_ADB structure
  501.  * which contains a table of values to decode the
  502.  * relevant type
  503.  */
  504.  
  505. #define ASN1_TFLG_ADB_MASK    (0x3<<8)
  506.  
  507. #define ASN1_TFLG_ADB_OID    (0x1<<8)
  508.  
  509. #define ASN1_TFLG_ADB_INT    (0x1<<9)
  510.  
  511. /* This flag means a parent structure is passed
  512.  * instead of the field: this is useful is a
  513.  * SEQUENCE is being combined with a CHOICE for
  514.  * example. Since this means the structure and
  515.  * item name will differ we need to use the
  516.  * ASN1_CHOICE_END_name() macro for example.
  517.  */
  518.  
  519. #define ASN1_TFLG_COMBINE    (0x1<<10)
  520.  
  521. /* This is the actual ASN1 item itself */
  522.  
  523. struct ASN1_ITEM_st {
  524. char itype;            /* The item type, primitive, SEQUENCE, CHOICE or extern */
  525. long utype;            /* underlying type */
  526. const ASN1_TEMPLATE *templates;    /* If SEQUENCE or CHOICE this contains the contents */
  527. long tcount;            /* Number of templates if SEQUENCE or CHOICE */
  528. const void *funcs;        /* functions that handle this type */
  529. long size;            /* Structure size (usually)*/
  530. #ifndef NO_ASN1_FIELD_NAMES
  531. const char *sname;        /* Structure name */
  532. #endif
  533. };
  534.  
  535. /* These are values for the itype field and
  536.  * determine how the type is interpreted.
  537.  *
  538.  * For PRIMITIVE types the underlying type
  539.  * determines the behaviour if items is NULL.
  540.  *
  541.  * Otherwise templates must contain a single 
  542.  * template and the type is treated in the
  543.  * same way as the type specified in the template.
  544.  *
  545.  * For SEQUENCE types the templates field points
  546.  * to the members, the size field is the
  547.  * structure size.
  548.  *
  549.  * For CHOICE types the templates field points
  550.  * to each possible member (typically a union)
  551.  * and the 'size' field is the offset of the
  552.  * selector.
  553.  *
  554.  * The 'funcs' field is used for application
  555.  * specific functions. 
  556.  *
  557.  * For COMPAT types the funcs field gives a
  558.  * set of functions that handle this type, this
  559.  * supports the old d2i, i2d convention.
  560.  *
  561.  * The EXTERN type uses a new style d2i/i2d.
  562.  * The new style should be used where possible
  563.  * because it avoids things like the d2i IMPLICIT
  564.  * hack.
  565.  *
  566.  * MSTRING is a multiple string type, it is used
  567.  * for a CHOICE of character strings where the
  568.  * actual strings all occupy an ASN1_STRING
  569.  * structure. In this case the 'utype' field
  570.  * has a special meaning, it is used as a mask
  571.  * of acceptable types using the B_ASN1 constants.
  572.  *
  573.  */
  574.  
  575. #define ASN1_ITYPE_PRIMITIVE    0x0
  576.  
  577. #define ASN1_ITYPE_SEQUENCE    0x1
  578.  
  579. #define ASN1_ITYPE_CHOICE    0x2
  580.  
  581. #define ASN1_ITYPE_COMPAT    0x3
  582.  
  583. #define ASN1_ITYPE_EXTERN    0x4
  584.  
  585. #define ASN1_ITYPE_MSTRING    0x5
  586.  
  587. /* Cache for ASN1 tag and length, so we
  588.  * don't keep re-reading it for things
  589.  * like CHOICE
  590.  */
  591.  
  592. struct ASN1_TLC_st{
  593.     char valid;    /* Values below are valid */
  594.     int ret;    /* return value */
  595.     long plen;    /* length */
  596.     int ptag;    /* class value */
  597.     int pclass;    /* class value */
  598.     int hdrlen;    /* header length */
  599. };
  600.  
  601. /* Typedefs for ASN1 function pointers */
  602.  
  603. typedef ASN1_VALUE * ASN1_new_func(void);
  604. typedef void ASN1_free_func(ASN1_VALUE *a);
  605. typedef ASN1_VALUE * ASN1_d2i_func(ASN1_VALUE **a, unsigned char ** in, long length);
  606. typedef int ASN1_i2d_func(ASN1_VALUE * a, unsigned char **in);
  607.  
  608. typedef int ASN1_ex_d2i(ASN1_VALUE **pval, unsigned char **in, long len, const ASN1_ITEM *it,
  609.                     int tag, int aclass, char opt, ASN1_TLC *ctx);
  610.  
  611. typedef int ASN1_ex_i2d(ASN1_VALUE **pval, unsigned char **out, const ASN1_ITEM *it, int tag, int aclass);
  612. typedef int ASN1_ex_new_func(ASN1_VALUE **pval, const ASN1_ITEM *it);
  613. typedef void ASN1_ex_free_func(ASN1_VALUE **pval, const ASN1_ITEM *it);
  614.  
  615. typedef int ASN1_primitive_i2c(ASN1_VALUE **pval, unsigned char *cont, int *putype, const ASN1_ITEM *it);
  616. typedef int ASN1_primitive_c2i(ASN1_VALUE **pval, unsigned char *cont, int len, int utype, char *free_cont, const ASN1_ITEM *it);
  617.  
  618. typedef struct ASN1_COMPAT_FUNCS_st {
  619.     ASN1_new_func *asn1_new;
  620.     ASN1_free_func *asn1_free;
  621.     ASN1_d2i_func *asn1_d2i;
  622.     ASN1_i2d_func *asn1_i2d;
  623. } ASN1_COMPAT_FUNCS;
  624.  
  625. typedef struct ASN1_EXTERN_FUNCS_st {
  626.     void *app_data;
  627.     ASN1_ex_new_func *asn1_ex_new;
  628.     ASN1_ex_free_func *asn1_ex_free;
  629.     ASN1_ex_free_func *asn1_ex_clear;
  630.     ASN1_ex_d2i *asn1_ex_d2i;
  631.     ASN1_ex_i2d *asn1_ex_i2d;
  632. } ASN1_EXTERN_FUNCS;
  633.  
  634. typedef struct ASN1_PRIMITIVE_FUNCS_st {
  635.     void *app_data;
  636.     unsigned long flags;
  637.     ASN1_ex_new_func *prim_new;
  638.     ASN1_ex_free_func *prim_free;
  639.     ASN1_ex_free_func *prim_clear;
  640.     ASN1_primitive_c2i *prim_c2i;
  641.     ASN1_primitive_i2c *prim_i2c;
  642. } ASN1_PRIMITIVE_FUNCS;
  643.  
  644. /* This is the ASN1_AUX structure: it handles various
  645.  * miscellaneous requirements. For example the use of
  646.  * reference counts and an informational callback.
  647.  *
  648.  * The "informational callback" is called at various
  649.  * points during the ASN1 encoding and decoding. It can
  650.  * be used to provide minor customisation of the structures
  651.  * used. This is most useful where the supplied routines
  652.  * *almost* do the right thing but need some extra help
  653.  * at a few points. If the callback returns zero then
  654.  * it is assumed a fatal error has occurred and the 
  655.  * main operation should be abandoned.
  656.  *
  657.  * If major changes in the default behaviour are required
  658.  * then an external type is more appropriate.
  659.  */
  660.  
  661. typedef int ASN1_aux_cb(int operation, ASN1_VALUE **in, const ASN1_ITEM *it);
  662.  
  663. typedef struct ASN1_AUX_st {
  664.     void *app_data;
  665.     int flags;
  666.     int ref_offset;        /* Offset of reference value */
  667.     int ref_lock;        /* Lock type to use */
  668.     ASN1_aux_cb *asn1_cb;
  669.     int enc_offset;        /* Offset of ASN1_ENCODING structure */
  670. } ASN1_AUX;
  671.  
  672. /* Flags in ASN1_AUX */
  673.  
  674. /* Use a reference count */
  675. #define ASN1_AFLG_REFCOUNT    1
  676. /* Save the encoding of structure (useful for signatures) */
  677. #define ASN1_AFLG_ENCODING    2
  678. /* The Sequence length is invalid */
  679. #define ASN1_AFLG_BROKEN    4
  680.  
  681. /* operation values for asn1_cb */
  682.  
  683. #define ASN1_OP_NEW_PRE        0
  684. #define ASN1_OP_NEW_POST    1
  685. #define ASN1_OP_FREE_PRE    2
  686. #define ASN1_OP_FREE_POST    3
  687. #define ASN1_OP_D2I_PRE        4
  688. #define ASN1_OP_D2I_POST    5
  689. #define ASN1_OP_I2D_PRE        6
  690. #define ASN1_OP_I2D_POST    7
  691.  
  692. /* Macro to implement a primitive type */
  693. #define IMPLEMENT_ASN1_TYPE(stname) IMPLEMENT_ASN1_TYPE_ex(stname, stname, 0)
  694. #define IMPLEMENT_ASN1_TYPE_ex(itname, vname, ex) \
  695.                 ASN1_ITEM_start(itname) \
  696.                     ASN1_ITYPE_PRIMITIVE, V_##vname, NULL, 0, NULL, ex, #itname \
  697.                 ASN1_ITEM_end(itname)
  698.  
  699. /* Macro to implement a multi string type */
  700. #define IMPLEMENT_ASN1_MSTRING(itname, mask) \
  701.                 ASN1_ITEM_start(itname) \
  702.                     ASN1_ITYPE_MSTRING, mask, NULL, 0, NULL, sizeof(ASN1_STRING), #itname \
  703.                 ASN1_ITEM_end(itname)
  704.  
  705. /* Macro to implement an ASN1_ITEM in terms of old style funcs */
  706.  
  707. #define IMPLEMENT_COMPAT_ASN1(sname) IMPLEMENT_COMPAT_ASN1_type(sname, V_ASN1_SEQUENCE)
  708.  
  709. #define IMPLEMENT_COMPAT_ASN1_type(sname, tag) \
  710.     static const ASN1_COMPAT_FUNCS sname##_ff = { \
  711.         (ASN1_new_func *)sname##_new, \
  712.         (ASN1_free_func *)sname##_free, \
  713.         (ASN1_d2i_func *)d2i_##sname, \
  714.         (ASN1_i2d_func *)i2d_##sname, \
  715.     }; \
  716.     ASN1_ITEM_start(sname) \
  717.         ASN1_ITYPE_COMPAT, \
  718.         tag, \
  719.         NULL, \
  720.         0, \
  721.         &sname##_ff, \
  722.         0, \
  723.         #sname \
  724.     ASN1_ITEM_end(sname)
  725.  
  726. #define IMPLEMENT_EXTERN_ASN1(sname, tag, fptrs) \
  727.     ASN1_ITEM_start(sname) \
  728.         ASN1_ITYPE_EXTERN, \
  729.         tag, \
  730.         NULL, \
  731.         0, \
  732.         &fptrs, \
  733.         0, \
  734.         #sname \
  735.     ASN1_ITEM_end(sname)
  736.  
  737. /* Macro to implement standard functions in terms of ASN1_ITEM structures */
  738.  
  739. #define IMPLEMENT_ASN1_FUNCTIONS(stname) IMPLEMENT_ASN1_FUNCTIONS_fname(stname, stname, stname)
  740.  
  741. #define IMPLEMENT_ASN1_FUNCTIONS_name(stname, itname) IMPLEMENT_ASN1_FUNCTIONS_fname(stname, itname, itname)
  742.  
  743. #define IMPLEMENT_ASN1_FUNCTIONS_ENCODE_name(stname, itname) \
  744.             IMPLEMENT_ASN1_FUNCTIONS_ENCODE_fname(stname, itname, itname)
  745.  
  746. #define IMPLEMENT_ASN1_ALLOC_FUNCTIONS_fname(stname, itname, fname) \
  747.     stname *fname##_new(void) \
  748.     { \
  749.         return (stname *)ASN1_item_new(ASN1_ITEM_rptr(itname)); \
  750.     } \
  751.     void fname##_free(stname *a) \
  752.     { \
  753.         ASN1_item_free((ASN1_VALUE *)a, ASN1_ITEM_rptr(itname)); \
  754.     }
  755.  
  756. #define IMPLEMENT_ASN1_FUNCTIONS_fname(stname, itname, fname) \
  757.     IMPLEMENT_ASN1_ENCODE_FUNCTIONS_fname(stname, itname, fname) \
  758.     IMPLEMENT_ASN1_ALLOC_FUNCTIONS_fname(stname, itname, fname)
  759.  
  760. #define IMPLEMENT_ASN1_ENCODE_FUNCTIONS_fname(stname, itname, fname) \
  761.     stname *d2i_##fname(stname **a, unsigned char **in, long len) \
  762.     { \
  763.         return (stname *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, ASN1_ITEM_rptr(itname));\
  764.     } \
  765.     int i2d_##fname(stname *a, unsigned char **out) \
  766.     { \
  767.         return ASN1_item_i2d((ASN1_VALUE *)a, out, ASN1_ITEM_rptr(itname));\
  768.     } 
  769.  
  770. /* This includes evil casts to remove const: they will go away when full
  771.  * ASN1 constification is done.
  772.  */
  773. #define IMPLEMENT_ASN1_ENCODE_FUNCTIONS_const_fname(stname, itname, fname) \
  774.     stname *d2i_##fname(stname **a, const unsigned char **in, long len) \
  775.     { \
  776.         return (stname *)ASN1_item_d2i((ASN1_VALUE **)a, (unsigned char **)in, len, ASN1_ITEM_rptr(itname));\
  777.     } \
  778.     int i2d_##fname(const stname *a, unsigned char **out) \
  779.     { \
  780.         return ASN1_item_i2d((ASN1_VALUE *)a, out, ASN1_ITEM_rptr(itname));\
  781.     } 
  782.  
  783. #define IMPLEMENT_ASN1_DUP_FUNCTION(stname) \
  784.     stname * stname##_dup(stname *x) \
  785.         { \
  786.         return ASN1_item_dup(ASN1_ITEM_rptr(stname), x); \
  787.         }
  788.  
  789. #define IMPLEMENT_ASN1_FUNCTIONS_const(name) \
  790.         IMPLEMENT_ASN1_FUNCTIONS_const_fname(name, name, name)
  791.  
  792. #define IMPLEMENT_ASN1_FUNCTIONS_const_fname(stname, itname, fname) \
  793.     IMPLEMENT_ASN1_ENCODE_FUNCTIONS_const_fname(stname, itname, fname) \
  794.     IMPLEMENT_ASN1_ALLOC_FUNCTIONS_fname(stname, itname, fname)
  795.  
  796. /* external definitions for primitive types */
  797.  
  798. DECLARE_ASN1_ITEM(ASN1_BOOLEAN)
  799. DECLARE_ASN1_ITEM(ASN1_TBOOLEAN)
  800. DECLARE_ASN1_ITEM(ASN1_FBOOLEAN)
  801. DECLARE_ASN1_ITEM(ASN1_ANY)
  802. DECLARE_ASN1_ITEM(ASN1_SEQUENCE)
  803. DECLARE_ASN1_ITEM(CBIGNUM)
  804. DECLARE_ASN1_ITEM(BIGNUM)
  805. DECLARE_ASN1_ITEM(LONG)
  806. DECLARE_ASN1_ITEM(ZLONG)
  807.  
  808. DECLARE_STACK_OF(ASN1_VALUE)
  809.  
  810. /* Functions used internally by the ASN1 code */
  811.  
  812. int ASN1_item_ex_new(ASN1_VALUE **pval, const ASN1_ITEM *it);
  813. void ASN1_item_ex_free(ASN1_VALUE **pval, const ASN1_ITEM *it);
  814. int ASN1_template_new(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt);
  815. int ASN1_primitive_new(ASN1_VALUE **pval, const ASN1_ITEM *it);
  816.  
  817. void ASN1_template_free(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt);
  818. int ASN1_template_d2i(ASN1_VALUE **pval, unsigned char **in, long len, const ASN1_TEMPLATE *tt);
  819. int ASN1_item_ex_d2i(ASN1_VALUE **pval, unsigned char **in, long len, const ASN1_ITEM *it,
  820.                 int tag, int aclass, char opt, ASN1_TLC *ctx);
  821.  
  822. int ASN1_item_ex_i2d(ASN1_VALUE **pval, unsigned char **out, const ASN1_ITEM *it, int tag, int aclass);
  823. int ASN1_template_i2d(ASN1_VALUE **pval, unsigned char **out, const ASN1_TEMPLATE *tt);
  824. void ASN1_primitive_free(ASN1_VALUE **pval, const ASN1_ITEM *it);
  825.  
  826. int asn1_ex_i2c(ASN1_VALUE **pval, unsigned char *cont, int *putype, const ASN1_ITEM *it);
  827. int asn1_ex_c2i(ASN1_VALUE **pval, unsigned char *cont, int len, int utype, char *free_cont, const ASN1_ITEM *it);
  828.  
  829. int asn1_get_choice_selector(ASN1_VALUE **pval, const ASN1_ITEM *it);
  830. int asn1_set_choice_selector(ASN1_VALUE **pval, int value, const ASN1_ITEM *it);
  831.  
  832. ASN1_VALUE ** asn1_get_field_ptr(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt);
  833.  
  834. const ASN1_TEMPLATE *asn1_do_adb(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt, int nullerr);
  835.  
  836. int asn1_do_lock(ASN1_VALUE **pval, int op, const ASN1_ITEM *it);
  837.  
  838. void asn1_enc_init(ASN1_VALUE **pval, const ASN1_ITEM *it);
  839. void asn1_enc_free(ASN1_VALUE **pval, const ASN1_ITEM *it);
  840. int asn1_enc_restore(int *len, unsigned char **out, ASN1_VALUE **pval, const ASN1_ITEM *it);
  841. int asn1_enc_save(ASN1_VALUE **pval, unsigned char *in, int inlen, const ASN1_ITEM *it);
  842.  
  843. #ifdef  __cplusplus
  844. }
  845. #endif
  846. #endif
  847.